<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html lang="en">

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
  <title>LCOV - iris.info - /usr/include/bits/wchar2.h</title>
  <link rel="stylesheet" type="text/css" href="../../../gcov.css">
</head>

<body>

  <table width="100%" border=0 cellspacing=0 cellpadding=0>
    <tr><td class="title">LTP GCOV extension - code coverage report</td></tr>
    <tr><td class="ruler"><img src="../../../glass.png" width=3 height=3 alt=""></td></tr>

    <tr>
      <td width="100%">
        <table cellpadding=1 border=0 width="100%">
        <tr>
          <td class="headerItem" width="20%">Current&nbsp;view:</td>
          <td class="headerValue" width="80%" colspan=4><a href="../../../index.html">directory</a> - <a href="index.html">usr/include/bits</a> - wchar2.h</td>
        </tr>
        <tr>
          <td class="headerItem" width="20%">Test:</td>
          <td class="headerValue" width="80%" colspan=4>iris.info</td>
        </tr>
        <tr>
          <td class="headerItem" width="20%">Date:</td>
          <td class="headerValue" width="20%">2010-05-24</td>
          <td width="20%"></td>
          <td class="headerItem" width="20%">Instrumented&nbsp;lines:</td>
          <td class="headerValue" width="20%">116</td>
        </tr>
        <tr>
          <td class="headerItem" width="20%">Code&nbsp;covered:</td>
          <td class="headerValue" width="20%">0.0 %</td>
          <td width="20%"></td>
          <td class="headerItem" width="20%">Executed&nbsp;lines:</td>
          <td class="headerValue" width="20%">0</td>
        </tr>
        </table>
      </td>
    </tr>
    <tr><td class="ruler"><img src="../../../glass.png" width=3 height=3 alt=""></td></tr>
  </table>

  <table cellpadding=0 cellspacing=0 border=0>
    <tr>
      <td><br></td>
    </tr>
    <tr>
      <td><pre class="source">
<span class="lineNum">       1 </span>                : /* Checking macros for wchar functions.
<span class="lineNum">       2 </span>                :    Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
<span class="lineNum">       3 </span>                :    This file is part of the GNU C Library.
<span class="lineNum">       4 </span>                : 
<span class="lineNum">       5 </span>                :    The GNU C Library is free software; you can redistribute it and/or
<span class="lineNum">       6 </span>                :    modify it under the terms of the GNU Lesser General Public
<span class="lineNum">       7 </span>                :    License as published by the Free Software Foundation; either
<span class="lineNum">       8 </span>                :    version 2.1 of the License, or (at your option) any later version.
<span class="lineNum">       9 </span>                : 
<span class="lineNum">      10 </span>                :    The GNU C Library is distributed in the hope that it will be useful,
<span class="lineNum">      11 </span>                :    but WITHOUT ANY WARRANTY; without even the implied warranty of
<span class="lineNum">      12 </span>                :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
<span class="lineNum">      13 </span>                :    Lesser General Public License for more details.
<span class="lineNum">      14 </span>                : 
<span class="lineNum">      15 </span>                :    You should have received a copy of the GNU Lesser General Public
<span class="lineNum">      16 </span>                :    License along with the GNU C Library; if not, write to the Free
<span class="lineNum">      17 </span>                :    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
<span class="lineNum">      18 </span>                :    02111-1307 USA.  */
<span class="lineNum">      19 </span>                : 
<span class="lineNum">      20 </span>                : #ifndef _WCHAR_H
<span class="lineNum">      21 </span>                : # error &quot;Never include &lt;bits/wchar2.h&gt; directly; use &lt;wchar.h&gt; instead.&quot;
<span class="lineNum">      22 </span>                : #endif
<span class="lineNum">      23 </span>                : 
<span class="lineNum">      24 </span>                : 
<span class="lineNum">      25 </span>                : extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1,
<span class="lineNum">      26 </span>                :                                __const wchar_t *__restrict __s2, size_t __n,
<span class="lineNum">      27 </span>                :                                size_t __ns1) __THROW;
<span class="lineNum">      28 </span>                : extern wchar_t *__REDIRECT_NTH (__wmemcpy_alias,
<span class="lineNum">      29 </span>                :                                 (wchar_t *__restrict __s1,
<span class="lineNum">      30 </span>                :                                  __const wchar_t *__restrict __s2, size_t __n),
<span class="lineNum">      31 </span>                :                                 wmemcpy);
<span class="lineNum">      32 </span>                : extern wchar_t *__REDIRECT_NTH (__wmemcpy_chk_warn,
<span class="lineNum">      33 </span>                :                                 (wchar_t *__restrict __s1,
<span class="lineNum">      34 </span>                :                                  __const wchar_t *__restrict __s2, size_t __n,
<span class="lineNum">      35 </span>                :                                  size_t __ns1), __wmemcpy_chk)
<span class="lineNum">      36 </span>                :      __warnattr (&quot;wmemcpy called with length bigger than size of destination &quot;
<span class="lineNum">      37 </span>                :                  &quot;buffer&quot;);
<span class="lineNum">      38 </span>                : 
<span class="lineNum">      39 </span>                : __extern_always_inline wchar_t *
<span class="lineNum">      40 </span><span class="lineNoCov">              0 : __NTH (wmemcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,</span>
<span class="lineNum">      41 </span>                :                 size_t __n))
<span class="lineNum">      42 </span>                : {
<span class="lineNum">      43 </span><span class="lineNoCov">              0 :   if (__bos0 (__s1) != (size_t) -1)</span>
<span class="lineNum">      44 </span>                :     {
<span class="lineNum">      45 </span><span class="lineNoCov">              0 :       if (!__builtin_constant_p (__n))</span>
<span class="lineNum">      46 </span>                :         return __wmemcpy_chk (__s1, __s2, __n,
<span class="lineNum">      47 </span><span class="lineNoCov">              0 :                               __bos0 (__s1) / sizeof (wchar_t));</span>
<span class="lineNum">      48 </span>                : 
<span class="lineNum">      49 </span><span class="lineNoCov">              0 :       if (__n &gt; __bos0 (__s1) / sizeof (wchar_t))</span>
<span class="lineNum">      50 </span>                :         return __wmemcpy_chk_warn (__s1, __s2, __n,
<span class="lineNum">      51 </span><span class="lineNoCov">              0 :                                    __bos0 (__s1) / sizeof (wchar_t));</span>
<span class="lineNum">      52 </span>                :     }
<span class="lineNum">      53 </span><span class="lineNoCov">              0 :   return __wmemcpy_alias (__s1, __s2, __n);</span>
<span class="lineNum">      54 </span>                : }
<span class="lineNum">      55 </span>                : 
<span class="lineNum">      56 </span>                : 
<span class="lineNum">      57 </span>                : extern wchar_t *__wmemmove_chk (wchar_t *__s1, __const wchar_t *__s2,
<span class="lineNum">      58 </span>                :                                 size_t __n, size_t __ns1) __THROW;
<span class="lineNum">      59 </span>                : extern wchar_t *__REDIRECT_NTH (__wmemmove_alias, (wchar_t *__s1,
<span class="lineNum">      60 </span>                :                                                    __const wchar_t *__s2,
<span class="lineNum">      61 </span>                :                                                    size_t __n), wmemmove);
<span class="lineNum">      62 </span>                : extern wchar_t *__REDIRECT_NTH (__wmemmove_chk_warn,
<span class="lineNum">      63 </span>                :                                 (wchar_t *__restrict __s1,
<span class="lineNum">      64 </span>                :                                  __const wchar_t *__restrict __s2, size_t __n,
<span class="lineNum">      65 </span>                :                                  size_t __ns1), __wmemmove_chk)
<span class="lineNum">      66 </span>                :      __warnattr (&quot;wmemmove called with length bigger than size of destination &quot;
<span class="lineNum">      67 </span>                :                  &quot;buffer&quot;);
<span class="lineNum">      68 </span>                : 
<span class="lineNum">      69 </span>                : __extern_always_inline wchar_t *
<span class="lineNum">      70 </span><span class="lineNoCov">              0 : __NTH (wmemmove (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,</span>
<span class="lineNum">      71 </span>                :                  size_t __n))
<span class="lineNum">      72 </span>                : {
<span class="lineNum">      73 </span><span class="lineNoCov">              0 :   if (__bos0 (__s1) != (size_t) -1)</span>
<span class="lineNum">      74 </span>                :     {
<span class="lineNum">      75 </span><span class="lineNoCov">              0 :       if (!__builtin_constant_p (__n))</span>
<span class="lineNum">      76 </span>                :         return __wmemmove_chk (__s1, __s2, __n,
<span class="lineNum">      77 </span><span class="lineNoCov">              0 :                                __bos0 (__s1) / sizeof (wchar_t));</span>
<span class="lineNum">      78 </span>                : 
<span class="lineNum">      79 </span><span class="lineNoCov">              0 :       if (__n &gt; __bos0 (__s1) / sizeof (wchar_t))</span>
<span class="lineNum">      80 </span>                :         return __wmemmove_chk_warn (__s1, __s2, __n,
<span class="lineNum">      81 </span><span class="lineNoCov">              0 :                                     __bos0 (__s1) / sizeof (wchar_t));</span>
<span class="lineNum">      82 </span>                :     }
<span class="lineNum">      83 </span><span class="lineNoCov">              0 :   return __wmemmove_alias (__s1, __s2, __n);</span>
<span class="lineNum">      84 </span>                : }
<span class="lineNum">      85 </span>                : 
<span class="lineNum">      86 </span>                : 
<span class="lineNum">      87 </span>                : #ifdef __USE_GNU
<span class="lineNum">      88 </span>                : extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1,
<span class="lineNum">      89 </span>                :                                 __const wchar_t *__restrict __s2, size_t __n,
<span class="lineNum">      90 </span>                :                                 size_t __ns1) __THROW;
<span class="lineNum">      91 </span>                : extern wchar_t *__REDIRECT_NTH (__wmempcpy_alias,
<span class="lineNum">      92 </span>                :                                 (wchar_t *__restrict __s1,
<span class="lineNum">      93 </span>                :                                  __const wchar_t *__restrict __s2,
<span class="lineNum">      94 </span>                :                                  size_t __n), wmempcpy);
<span class="lineNum">      95 </span>                : extern wchar_t *__REDIRECT_NTH (__wmempcpy_chk_warn,
<span class="lineNum">      96 </span>                :                                 (wchar_t *__restrict __s1,
<span class="lineNum">      97 </span>                :                                  __const wchar_t *__restrict __s2, size_t __n,
<span class="lineNum">      98 </span>                :                                  size_t __ns1), __wmempcpy_chk)
<span class="lineNum">      99 </span>                :      __warnattr (&quot;wmempcpy called with length bigger than size of destination &quot;
<span class="lineNum">     100 </span>                :                  &quot;buffer&quot;);
<span class="lineNum">     101 </span>                : 
<span class="lineNum">     102 </span>                : __extern_always_inline wchar_t *
<span class="lineNum">     103 </span><span class="lineNoCov">              0 : __NTH (wmempcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2,</span>
<span class="lineNum">     104 </span>                :                  size_t __n))
<span class="lineNum">     105 </span>                : {
<span class="lineNum">     106 </span><span class="lineNoCov">              0 :   if (__bos0 (__s1) != (size_t) -1)</span>
<span class="lineNum">     107 </span>                :     {
<span class="lineNum">     108 </span><span class="lineNoCov">              0 :       if (!__builtin_constant_p (__n))</span>
<span class="lineNum">     109 </span>                :         return __wmempcpy_chk (__s1, __s2, __n,
<span class="lineNum">     110 </span><span class="lineNoCov">              0 :                                __bos0 (__s1) / sizeof (wchar_t));</span>
<span class="lineNum">     111 </span>                : 
<span class="lineNum">     112 </span><span class="lineNoCov">              0 :       if (__n &gt; __bos0 (__s1) / sizeof (wchar_t))</span>
<span class="lineNum">     113 </span>                :         return __wmempcpy_chk_warn (__s1, __s2, __n,
<span class="lineNum">     114 </span><span class="lineNoCov">              0 :                                     __bos0 (__s1) / sizeof (wchar_t));</span>
<span class="lineNum">     115 </span>                :     }
<span class="lineNum">     116 </span><span class="lineNoCov">              0 :   return __wmempcpy_alias (__s1, __s2, __n);</span>
<span class="lineNum">     117 </span>                : }
<span class="lineNum">     118 </span>                : #endif
<span class="lineNum">     119 </span>                : 
<span class="lineNum">     120 </span>                : 
<span class="lineNum">     121 </span>                : extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n,
<span class="lineNum">     122 </span>                :                                size_t __ns) __THROW;
<span class="lineNum">     123 </span>                : extern wchar_t *__REDIRECT_NTH (__wmemset_alias, (wchar_t *__s, wchar_t __c,
<span class="lineNum">     124 </span>                :                                                   size_t __n), wmemset);
<span class="lineNum">     125 </span>                : extern wchar_t *__REDIRECT_NTH (__wmemset_chk_warn,
<span class="lineNum">     126 </span>                :                                 (wchar_t *__s, wchar_t __c, size_t __n,
<span class="lineNum">     127 </span>                :                                  size_t __ns), __wmemset_chk)
<span class="lineNum">     128 </span>                :      __warnattr (&quot;wmemset called with length bigger than size of destination &quot;
<span class="lineNum">     129 </span>                :                  &quot;buffer&quot;);
<span class="lineNum">     130 </span>                : 
<span class="lineNum">     131 </span>                : __extern_always_inline wchar_t *
<span class="lineNum">     132 </span><span class="lineNoCov">              0 : __NTH (wmemset (wchar_t *__restrict __s, wchar_t __c, size_t __n))</span>
<span class="lineNum">     133 </span>                : {
<span class="lineNum">     134 </span><span class="lineNoCov">              0 :   if (__bos0 (__s) != (size_t) -1)</span>
<span class="lineNum">     135 </span>                :     {
<span class="lineNum">     136 </span><span class="lineNoCov">              0 :       if (!__builtin_constant_p (__n))</span>
<span class="lineNum">     137 </span><span class="lineNoCov">              0 :         return __wmemset_chk (__s, __c, __n, __bos0 (__s) / sizeof (wchar_t));</span>
<span class="lineNum">     138 </span>                : 
<span class="lineNum">     139 </span><span class="lineNoCov">              0 :       if (__n &gt; __bos0 (__s) / sizeof (wchar_t))</span>
<span class="lineNum">     140 </span>                :         return __wmemset_chk_warn (__s, __c, __n,
<span class="lineNum">     141 </span><span class="lineNoCov">              0 :                                    __bos0 (__s) / sizeof (wchar_t));</span>
<span class="lineNum">     142 </span>                :     }
<span class="lineNum">     143 </span><span class="lineNoCov">              0 :   return __wmemset_alias (__s, __c, __n);</span>
<span class="lineNum">     144 </span>                : }
<span class="lineNum">     145 </span>                : 
<span class="lineNum">     146 </span>                : 
<span class="lineNum">     147 </span>                : extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest,
<span class="lineNum">     148 </span>                :                               __const wchar_t *__restrict __src,
<span class="lineNum">     149 </span>                :                               size_t __n) __THROW;
<span class="lineNum">     150 </span>                : extern wchar_t *__REDIRECT_NTH (__wcscpy_alias,
<span class="lineNum">     151 </span>                :                                 (wchar_t *__restrict __dest,
<span class="lineNum">     152 </span>                :                                  __const wchar_t *__restrict __src), wcscpy);
<span class="lineNum">     153 </span>                : 
<span class="lineNum">     154 </span>                : __extern_always_inline wchar_t *
<span class="lineNum">     155 </span><span class="lineNoCov">              0 : __NTH (wcscpy (wchar_t *__dest, __const wchar_t *__src))</span>
<span class="lineNum">     156 </span>                : {
<span class="lineNum">     157 </span><span class="lineNoCov">              0 :   if (__bos (__dest) != (size_t) -1)</span>
<span class="lineNum">     158 </span><span class="lineNoCov">              0 :     return __wcscpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));</span>
<span class="lineNum">     159 </span><span class="lineNoCov">              0 :   return __wcscpy_alias (__dest, __src);</span>
<span class="lineNum">     160 </span>                : }
<span class="lineNum">     161 </span>                : 
<span class="lineNum">     162 </span>                : 
<span class="lineNum">     163 </span>                : extern wchar_t *__wcpcpy_chk (wchar_t *__dest, __const wchar_t *__src,
<span class="lineNum">     164 </span>                :                               size_t __destlen) __THROW;
<span class="lineNum">     165 </span>                : extern wchar_t *__REDIRECT_NTH (__wcpcpy_alias, (wchar_t *__dest,
<span class="lineNum">     166 </span>                :                                                  __const wchar_t *__src),
<span class="lineNum">     167 </span>                :                                 wcpcpy);
<span class="lineNum">     168 </span>                : 
<span class="lineNum">     169 </span>                : __extern_always_inline wchar_t *
<span class="lineNum">     170 </span><span class="lineNoCov">              0 : __NTH (wcpcpy (wchar_t *__dest, __const wchar_t *__src))</span>
<span class="lineNum">     171 </span>                : {
<span class="lineNum">     172 </span><span class="lineNoCov">              0 :   if (__bos (__dest) != (size_t) -1)</span>
<span class="lineNum">     173 </span><span class="lineNoCov">              0 :     return __wcpcpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));</span>
<span class="lineNum">     174 </span><span class="lineNoCov">              0 :   return __wcpcpy_alias (__dest, __src);</span>
<span class="lineNum">     175 </span>                : }
<span class="lineNum">     176 </span>                : 
<span class="lineNum">     177 </span>                : 
<span class="lineNum">     178 </span>                : extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest,
<span class="lineNum">     179 </span>                :                                __const wchar_t *__restrict __src, size_t __n,
<span class="lineNum">     180 </span>                :                                size_t __destlen) __THROW;
<span class="lineNum">     181 </span>                : extern wchar_t *__REDIRECT_NTH (__wcsncpy_alias,
<span class="lineNum">     182 </span>                :                                 (wchar_t *__restrict __dest,
<span class="lineNum">     183 </span>                :                                  __const wchar_t *__restrict __src,
<span class="lineNum">     184 </span>                :                                  size_t __n), wcsncpy);
<span class="lineNum">     185 </span>                : extern wchar_t *__REDIRECT_NTH (__wcsncpy_chk_warn,
<span class="lineNum">     186 </span>                :                                 (wchar_t *__restrict __dest,
<span class="lineNum">     187 </span>                :                                  __const wchar_t *__restrict __src,
<span class="lineNum">     188 </span>                :                                  size_t __n, size_t __destlen), __wcsncpy_chk)
<span class="lineNum">     189 </span>                :      __warnattr (&quot;wcsncpy called with length bigger than size of destination &quot;
<span class="lineNum">     190 </span>                :                  &quot;buffer&quot;);
<span class="lineNum">     191 </span>                : 
<span class="lineNum">     192 </span>                : __extern_always_inline wchar_t *
<span class="lineNum">     193 </span><span class="lineNoCov">              0 : __NTH (wcsncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n))</span>
<span class="lineNum">     194 </span>                : {
<span class="lineNum">     195 </span><span class="lineNoCov">              0 :   if (__bos (__dest) != (size_t) -1)</span>
<span class="lineNum">     196 </span>                :     {
<span class="lineNum">     197 </span><span class="lineNoCov">              0 :       if (!__builtin_constant_p (__n))</span>
<span class="lineNum">     198 </span>                :         return __wcsncpy_chk (__dest, __src, __n,
<span class="lineNum">     199 </span><span class="lineNoCov">              0 :                               __bos (__dest) / sizeof (wchar_t));</span>
<span class="lineNum">     200 </span><span class="lineNoCov">              0 :       if (__n &gt; __bos (__dest) / sizeof (wchar_t))</span>
<span class="lineNum">     201 </span>                :         return __wcsncpy_chk_warn (__dest, __src, __n,
<span class="lineNum">     202 </span><span class="lineNoCov">              0 :                                    __bos (__dest) / sizeof (wchar_t));</span>
<span class="lineNum">     203 </span>                :     }
<span class="lineNum">     204 </span><span class="lineNoCov">              0 :   return __wcsncpy_alias (__dest, __src, __n);</span>
<span class="lineNum">     205 </span>                : }
<span class="lineNum">     206 </span>                : 
<span class="lineNum">     207 </span>                : 
<span class="lineNum">     208 </span>                : extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest,
<span class="lineNum">     209 </span>                :                                __const wchar_t *__restrict __src, size_t __n,
<span class="lineNum">     210 </span>                :                                size_t __destlen) __THROW;
<span class="lineNum">     211 </span>                : extern wchar_t *__REDIRECT_NTH (__wcpncpy_alias,
<span class="lineNum">     212 </span>                :                                 (wchar_t *__restrict __dest,
<span class="lineNum">     213 </span>                :                                  __const wchar_t *__restrict __src,
<span class="lineNum">     214 </span>                :                                  size_t __n), wcpncpy);
<span class="lineNum">     215 </span>                : extern wchar_t *__REDIRECT_NTH (__wcpncpy_chk_warn,
<span class="lineNum">     216 </span>                :                                 (wchar_t *__restrict __dest,
<span class="lineNum">     217 </span>                :                                  __const wchar_t *__restrict __src,
<span class="lineNum">     218 </span>                :                                  size_t __n, size_t __destlen), __wcpncpy_chk)
<span class="lineNum">     219 </span>                :      __warnattr (&quot;wcpncpy called with length bigger than size of destination &quot;
<span class="lineNum">     220 </span>                :                  &quot;buffer&quot;);
<span class="lineNum">     221 </span>                : 
<span class="lineNum">     222 </span>                : __extern_always_inline wchar_t *
<span class="lineNum">     223 </span><span class="lineNoCov">              0 : __NTH (wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n))</span>
<span class="lineNum">     224 </span>                : {
<span class="lineNum">     225 </span><span class="lineNoCov">              0 :   if (__bos (__dest) != (size_t) -1)</span>
<span class="lineNum">     226 </span>                :     {
<span class="lineNum">     227 </span><span class="lineNoCov">              0 :       if (!__builtin_constant_p (__n))</span>
<span class="lineNum">     228 </span>                :         return __wcpncpy_chk (__dest, __src, __n,
<span class="lineNum">     229 </span><span class="lineNoCov">              0 :                               __bos (__dest) / sizeof (wchar_t));</span>
<span class="lineNum">     230 </span><span class="lineNoCov">              0 :       if (__n &gt; __bos (__dest) / sizeof (wchar_t))</span>
<span class="lineNum">     231 </span>                :         return __wcpncpy_chk_warn (__dest, __src, __n,
<span class="lineNum">     232 </span><span class="lineNoCov">              0 :                                    __bos (__dest) / sizeof (wchar_t));</span>
<span class="lineNum">     233 </span>                :     }
<span class="lineNum">     234 </span><span class="lineNoCov">              0 :   return __wcpncpy_alias (__dest, __src, __n);</span>
<span class="lineNum">     235 </span>                : }
<span class="lineNum">     236 </span>                : 
<span class="lineNum">     237 </span>                : 
<span class="lineNum">     238 </span>                : extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest,
<span class="lineNum">     239 </span>                :                               __const wchar_t *__restrict __src,
<span class="lineNum">     240 </span>                :                               size_t __destlen) __THROW;
<span class="lineNum">     241 </span>                : extern wchar_t *__REDIRECT_NTH (__wcscat_alias,
<span class="lineNum">     242 </span>                :                                 (wchar_t *__restrict __dest,
<span class="lineNum">     243 </span>                :                                  __const wchar_t *__restrict __src), wcscat);
<span class="lineNum">     244 </span>                : 
<span class="lineNum">     245 </span>                : __extern_always_inline wchar_t *
<span class="lineNum">     246 </span><span class="lineNoCov">              0 : __NTH (wcscat (wchar_t *__dest, __const wchar_t *__src))</span>
<span class="lineNum">     247 </span>                : {
<span class="lineNum">     248 </span><span class="lineNoCov">              0 :   if (__bos (__dest) != (size_t) -1)</span>
<span class="lineNum">     249 </span><span class="lineNoCov">              0 :     return __wcscat_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t));</span>
<span class="lineNum">     250 </span><span class="lineNoCov">              0 :   return __wcscat_alias (__dest, __src);</span>
<span class="lineNum">     251 </span>                : }
<span class="lineNum">     252 </span>                : 
<span class="lineNum">     253 </span>                : 
<span class="lineNum">     254 </span>                : extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest,
<span class="lineNum">     255 </span>                :                                __const wchar_t *__restrict __src,
<span class="lineNum">     256 </span>                :                                size_t __n, size_t __destlen) __THROW;
<span class="lineNum">     257 </span>                : extern wchar_t *__REDIRECT_NTH (__wcsncat_alias,
<span class="lineNum">     258 </span>                :                                 (wchar_t *__restrict __dest,
<span class="lineNum">     259 </span>                :                                  __const wchar_t *__restrict __src,
<span class="lineNum">     260 </span>                :                                  size_t __n), wcsncat);
<span class="lineNum">     261 </span>                : 
<span class="lineNum">     262 </span>                : __extern_always_inline wchar_t *
<span class="lineNum">     263 </span><span class="lineNoCov">              0 : __NTH (wcsncat (wchar_t *__dest, __const wchar_t *__src, size_t __n))</span>
<span class="lineNum">     264 </span>                : {
<span class="lineNum">     265 </span><span class="lineNoCov">              0 :   if (__bos (__dest) != (size_t) -1)</span>
<span class="lineNum">     266 </span>                :     return __wcsncat_chk (__dest, __src, __n,
<span class="lineNum">     267 </span><span class="lineNoCov">              0 :                           __bos (__dest) / sizeof (wchar_t));</span>
<span class="lineNum">     268 </span><span class="lineNoCov">              0 :   return __wcsncat_alias (__dest, __src, __n);</span>
<span class="lineNum">     269 </span>                : }
<span class="lineNum">     270 </span>                : 
<span class="lineNum">     271 </span>                : 
<span class="lineNum">     272 </span>                : extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n,
<span class="lineNum">     273 </span>                :                            int __flag, size_t __s_len,
<span class="lineNum">     274 </span>                :                            __const wchar_t *__restrict __format, ...)
<span class="lineNum">     275 </span>                :      __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 6))) */;
<span class="lineNum">     276 </span>                : 
<span class="lineNum">     277 </span>                : extern int __REDIRECT_NTH_LDBL (__swprintf_alias,
<span class="lineNum">     278 </span>                :                                 (wchar_t *__restrict __s, size_t __n,
<span class="lineNum">     279 </span>                :                                  __const wchar_t *__restrict __fmt, ...),
<span class="lineNum">     280 </span>                :                                 swprintf);
<span class="lineNum">     281 </span>                : 
<span class="lineNum">     282 </span>                : #ifdef __va_arg_pack
<span class="lineNum">     283 </span>                : __extern_always_inline int
<span class="lineNum">     284 </span><span class="lineNoCov">              0 : __NTH (swprintf (wchar_t *__restrict __s, size_t __n,</span>
<span class="lineNum">     285 </span>                :                  __const wchar_t *__restrict __fmt, ...))
<span class="lineNum">     286 </span>                : {
<span class="lineNum">     287 </span>                :   if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL &gt; 1)
<span class="lineNum">     288 </span>                :     return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
<span class="lineNum">     289 </span>                :                            __bos (__s) / sizeof (wchar_t),
<span class="lineNum">     290 </span><span class="lineNoCov">              0 :                            __fmt, __va_arg_pack ());</span>
<span class="lineNum">     291 </span>                :   return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ());
<span class="lineNum">     292 </span>                : }
<span class="lineNum">     293 </span>                : #elif !defined __cplusplus
<span class="lineNum">     294 </span>                : /* XXX We might want to have support in gcc for swprintf.  */
<span class="lineNum">     295 </span>                : # define swprintf(s, n, ...) \
<span class="lineNum">     296 </span>                :   (__bos (s) != (size_t) -1 || __USE_FORTIFY_LEVEL &gt; 1                             \
<span class="lineNum">     297 </span>                :    ? __swprintf_chk (s, n, __USE_FORTIFY_LEVEL - 1,                           \
<span class="lineNum">     298 </span>                :                      __bos (s) / sizeof (wchar_t), __VA_ARGS__)               \
<span class="lineNum">     299 </span>                :    : swprintf (s, n, __VA_ARGS__))
<span class="lineNum">     300 </span>                : #endif
<span class="lineNum">     301 </span>                : 
<span class="lineNum">     302 </span>                : extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n,
<span class="lineNum">     303 </span>                :                             int __flag, size_t __s_len,
<span class="lineNum">     304 </span>                :                             __const wchar_t *__restrict __format,
<span class="lineNum">     305 </span>                :                             __gnuc_va_list __arg)
<span class="lineNum">     306 </span>                :      __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 0))) */;
<span class="lineNum">     307 </span>                : 
<span class="lineNum">     308 </span>                : extern int __REDIRECT_NTH_LDBL (__vswprintf_alias,
<span class="lineNum">     309 </span>                :                                 (wchar_t *__restrict __s, size_t __n,
<span class="lineNum">     310 </span>                :                                  __const wchar_t *__restrict __fmt,
<span class="lineNum">     311 </span>                :                                  __gnuc_va_list __ap), vswprintf);
<span class="lineNum">     312 </span>                : 
<span class="lineNum">     313 </span>                : __extern_always_inline int
<span class="lineNum">     314 </span><span class="lineNoCov">              0 : __NTH (vswprintf (wchar_t *__restrict __s, size_t __n,</span>
<span class="lineNum">     315 </span>                :                   __const wchar_t *__restrict __fmt, __gnuc_va_list __ap))
<span class="lineNum">     316 </span>                : {
<span class="lineNum">     317 </span>                :   if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL &gt; 1)
<span class="lineNum">     318 </span>                :     return __vswprintf_chk (__s, __n,  __USE_FORTIFY_LEVEL - 1,
<span class="lineNum">     319 </span><span class="lineNoCov">              0 :                             __bos (__s) / sizeof (wchar_t), __fmt, __ap);</span>
<span class="lineNum">     320 </span>                :   return __vswprintf_alias (__s, __n, __fmt, __ap);
<span class="lineNum">     321 </span>                : }
<span class="lineNum">     322 </span>                : 
<span class="lineNum">     323 </span>                : 
<span class="lineNum">     324 </span>                : #if __USE_FORTIFY_LEVEL &gt; 1
<span class="lineNum">     325 </span>                : 
<span class="lineNum">     326 </span>                : extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag,
<span class="lineNum">     327 </span>                :                            __const wchar_t *__restrict __format, ...);
<span class="lineNum">     328 </span>                : extern int __wprintf_chk (int __flag, __const wchar_t *__restrict __format,
<span class="lineNum">     329 </span>                :                           ...);
<span class="lineNum">     330 </span>                : extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag,
<span class="lineNum">     331 </span>                :                             __const wchar_t *__restrict __format,
<span class="lineNum">     332 </span>                :                             __gnuc_va_list __ap);
<span class="lineNum">     333 </span>                : extern int __vwprintf_chk (int __flag, __const wchar_t *__restrict __format,
<span class="lineNum">     334 </span>                :                            __gnuc_va_list __ap);
<span class="lineNum">     335 </span>                : 
<span class="lineNum">     336 </span>                : # ifdef __va_arg_pack
<span class="lineNum">     337 </span>                : __extern_always_inline int
<span class="lineNum">     338 </span><span class="lineNoCov">              0 : wprintf (__const wchar_t *__restrict __fmt, ...)</span>
<span class="lineNum">     339 </span>                : {
<span class="lineNum">     340 </span><span class="lineNoCov">              0 :   return __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ());</span>
<span class="lineNum">     341 </span>                : }
<span class="lineNum">     342 </span>                : 
<span class="lineNum">     343 </span>                : __extern_always_inline int
<span class="lineNum">     344 </span><span class="lineNoCov">              0 : fwprintf (__FILE *__restrict __stream, __const wchar_t *__restrict __fmt, ...)</span>
<span class="lineNum">     345 </span>                : {
<span class="lineNum">     346 </span>                :   return __fwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt,
<span class="lineNum">     347 </span><span class="lineNoCov">              0 :                          __va_arg_pack ());</span>
<span class="lineNum">     348 </span>                : }
<span class="lineNum">     349 </span>                : # elif !defined __cplusplus
<span class="lineNum">     350 </span>                : #  define wprintf(...) \
<span class="lineNum">     351 </span>                :   __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
<span class="lineNum">     352 </span>                : #  define fwprintf(stream, ...) \
<span class="lineNum">     353 </span>                :   __fwprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__)
<span class="lineNum">     354 </span>                : # endif
<span class="lineNum">     355 </span>                : 
<span class="lineNum">     356 </span>                : __extern_always_inline int
<span class="lineNum">     357 </span><span class="lineNoCov">              0 : vwprintf (__const wchar_t *__restrict __fmt, __gnuc_va_list __ap)</span>
<span class="lineNum">     358 </span>                : {
<span class="lineNum">     359 </span><span class="lineNoCov">              0 :   return __vwprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap);</span>
<span class="lineNum">     360 </span>                : }
<span class="lineNum">     361 </span>                : 
<span class="lineNum">     362 </span>                : __extern_always_inline int
<span class="lineNum">     363 </span>                : vfwprintf (__FILE *__restrict __stream,
<span class="lineNum">     364 </span><span class="lineNoCov">              0 :            __const wchar_t *__restrict __fmt, __gnuc_va_list __ap)</span>
<span class="lineNum">     365 </span>                : {
<span class="lineNum">     366 </span><span class="lineNoCov">              0 :   return __vfwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap);</span>
<span class="lineNum">     367 </span>                : }
<span class="lineNum">     368 </span>                : 
<span class="lineNum">     369 </span>                : #endif
<span class="lineNum">     370 </span>                : 
<span class="lineNum">     371 </span>                : extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n,
<span class="lineNum">     372 </span>                :                               __FILE *__restrict __stream) __wur;
<span class="lineNum">     373 </span>                : extern wchar_t *__REDIRECT (__fgetws_alias,
<span class="lineNum">     374 </span>                :                             (wchar_t *__restrict __s, int __n,
<span class="lineNum">     375 </span>                :                              __FILE *__restrict __stream), fgetws) __wur;
<span class="lineNum">     376 </span>                : extern wchar_t *__REDIRECT (__fgetws_chk_warn,
<span class="lineNum">     377 </span>                :                             (wchar_t *__restrict __s, size_t __size, int __n,
<span class="lineNum">     378 </span>                :                              __FILE *__restrict __stream), __fgetws_chk)
<span class="lineNum">     379 </span>                :      __wur __warnattr (&quot;fgetws called with bigger size than length &quot;
<span class="lineNum">     380 </span>                :                        &quot;of destination buffer&quot;);
<span class="lineNum">     381 </span>                : 
<span class="lineNum">     382 </span>                : __extern_always_inline __wur wchar_t *
<span class="lineNum">     383 </span><span class="lineNoCov">              0 : fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)</span>
<span class="lineNum">     384 </span>                : {
<span class="lineNum">     385 </span><span class="lineNoCov">              0 :   if (__bos (__s) != (size_t) -1)</span>
<span class="lineNum">     386 </span>                :     {
<span class="lineNum">     387 </span><span class="lineNoCov">              0 :       if (!__builtin_constant_p (__n) || __n &lt;= 0)</span>
<span class="lineNum">     388 </span>                :         return __fgetws_chk (__s, __bos (__s) / sizeof (wchar_t),
<span class="lineNum">     389 </span><span class="lineNoCov">              0 :                              __n, __stream);</span>
<span class="lineNum">     390 </span>                : 
<span class="lineNum">     391 </span><span class="lineNoCov">              0 :       if ((size_t) __n &gt; __bos (__s) / sizeof (wchar_t))</span>
<span class="lineNum">     392 </span>                :         return __fgetws_chk_warn (__s, __bos (__s) / sizeof (wchar_t),
<span class="lineNum">     393 </span><span class="lineNoCov">              0 :                                   __n, __stream);</span>
<span class="lineNum">     394 </span>                :     }
<span class="lineNum">     395 </span><span class="lineNoCov">              0 :   return __fgetws_alias (__s, __n, __stream);</span>
<span class="lineNum">     396 </span>                : }
<span class="lineNum">     397 </span>                : 
<span class="lineNum">     398 </span>                : #ifdef __USE_GNU
<span class="lineNum">     399 </span>                : extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size,
<span class="lineNum">     400 </span>                :                                        int __n, __FILE *__restrict __stream)
<span class="lineNum">     401 </span>                :   __wur;
<span class="lineNum">     402 </span>                : extern wchar_t *__REDIRECT (__fgetws_unlocked_alias,
<span class="lineNum">     403 </span>                :                             (wchar_t *__restrict __s, int __n,
<span class="lineNum">     404 </span>                :                              __FILE *__restrict __stream), fgetws_unlocked)
<span class="lineNum">     405 </span>                :   __wur;
<span class="lineNum">     406 </span>                : extern wchar_t *__REDIRECT (__fgetws_unlocked_chk_warn,
<span class="lineNum">     407 </span>                :                             (wchar_t *__restrict __s, size_t __size, int __n,
<span class="lineNum">     408 </span>                :                              __FILE *__restrict __stream),
<span class="lineNum">     409 </span>                :                             __fgetws_unlocked_chk)
<span class="lineNum">     410 </span>                :      __wur __warnattr (&quot;fgetws_unlocked called with bigger size than length &quot;
<span class="lineNum">     411 </span>                :                        &quot;of destination buffer&quot;);
<span class="lineNum">     412 </span>                : 
<span class="lineNum">     413 </span>                : __extern_always_inline __wur wchar_t *
<span class="lineNum">     414 </span><span class="lineNoCov">              0 : fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)</span>
<span class="lineNum">     415 </span>                : {
<span class="lineNum">     416 </span><span class="lineNoCov">              0 :   if (__bos (__s) != (size_t) -1)</span>
<span class="lineNum">     417 </span>                :     {
<span class="lineNum">     418 </span><span class="lineNoCov">              0 :       if (!__builtin_constant_p (__n) || __n &lt;= 0)</span>
<span class="lineNum">     419 </span>                :         return __fgetws_unlocked_chk (__s, __bos (__s) / sizeof (wchar_t),
<span class="lineNum">     420 </span><span class="lineNoCov">              0 :                                       __n, __stream);</span>
<span class="lineNum">     421 </span>                : 
<span class="lineNum">     422 </span><span class="lineNoCov">              0 :       if ((size_t) __n &gt; __bos (__s) / sizeof (wchar_t))</span>
<span class="lineNum">     423 </span>                :         return __fgetws_unlocked_chk_warn (__s, __bos (__s) / sizeof (wchar_t),
<span class="lineNum">     424 </span><span class="lineNoCov">              0 :                                            __n, __stream);</span>
<span class="lineNum">     425 </span>                :     }
<span class="lineNum">     426 </span><span class="lineNoCov">              0 :   return __fgetws_unlocked_alias (__s, __n, __stream);</span>
<span class="lineNum">     427 </span>                : }
<span class="lineNum">     428 </span>                : #endif
<span class="lineNum">     429 </span>                : 
<span class="lineNum">     430 </span>                : 
<span class="lineNum">     431 </span>                : extern size_t __wcrtomb_chk (char *__s, wchar_t __wchar, mbstate_t *__p,
<span class="lineNum">     432 </span>                :                           size_t __buflen) __THROW __wur;
<span class="lineNum">     433 </span>                : extern size_t __REDIRECT_NTH (__wcrtomb_alias,
<span class="lineNum">     434 </span>                :                               (char *__restrict __s, wchar_t __wchar,
<span class="lineNum">     435 </span>                :                                mbstate_t *__restrict __ps), wcrtomb) __wur;
<span class="lineNum">     436 </span>                : 
<span class="lineNum">     437 </span>                : __extern_always_inline __wur size_t
<span class="lineNum">     438 </span><span class="lineNoCov">              0 : __NTH (wcrtomb (char *__s, wchar_t __wchar, mbstate_t *__ps))</span>
<span class="lineNum">     439 </span>                : {
<span class="lineNum">     440 </span>                :   /* We would have to include &lt;limits.h&gt; to get a definition of MB_LEN_MAX.
<span class="lineNum">     441 </span>                :      But this would only disturb the namespace.  So we define our own
<span class="lineNum">     442 </span>                :      version here.  */
<span class="lineNum">     443 </span>                : #define __WCHAR_MB_LEN_MAX      16
<span class="lineNum">     444 </span>                : #if defined MB_LEN_MAX &amp;&amp; MB_LEN_MAX != __WCHAR_MB_LEN_MAX
<span class="lineNum">     445 </span>                : # error &quot;Assumed value of MB_LEN_MAX wrong&quot;
<span class="lineNum">     446 </span>                : #endif
<span class="lineNum">     447 </span><span class="lineNoCov">              0 :   if (__bos (__s) != (size_t) -1 &amp;&amp; __WCHAR_MB_LEN_MAX &gt; __bos (__s))</span>
<span class="lineNum">     448 </span><span class="lineNoCov">              0 :     return __wcrtomb_chk (__s, __wchar, __ps, __bos (__s));</span>
<span class="lineNum">     449 </span><span class="lineNoCov">              0 :   return __wcrtomb_alias (__s, __wchar, __ps);</span>
<span class="lineNum">     450 </span>                : }
<span class="lineNum">     451 </span>                : 
<span class="lineNum">     452 </span>                : 
<span class="lineNum">     453 </span>                : extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst,
<span class="lineNum">     454 </span>                :                                __const char **__restrict __src,
<span class="lineNum">     455 </span>                :                                size_t __len, mbstate_t *__restrict __ps,
<span class="lineNum">     456 </span>                :                                size_t __dstlen) __THROW;
<span class="lineNum">     457 </span>                : extern size_t __REDIRECT_NTH (__mbsrtowcs_alias,
<span class="lineNum">     458 </span>                :                               (wchar_t *__restrict __dst,
<span class="lineNum">     459 </span>                :                                __const char **__restrict __src,
<span class="lineNum">     460 </span>                :                                size_t __len, mbstate_t *__restrict __ps),
<span class="lineNum">     461 </span>                :                               mbsrtowcs);
<span class="lineNum">     462 </span>                : extern size_t __REDIRECT_NTH (__mbsrtowcs_chk_warn,
<span class="lineNum">     463 </span>                :                               (wchar_t *__restrict __dst,
<span class="lineNum">     464 </span>                :                                __const char **__restrict __src,
<span class="lineNum">     465 </span>                :                                size_t __len, mbstate_t *__restrict __ps,
<span class="lineNum">     466 </span>                :                                size_t __dstlen), __mbsrtowcs_chk)
<span class="lineNum">     467 </span>                :      __warnattr (&quot;mbsrtowcs called with dst buffer smaller than len &quot;
<span class="lineNum">     468 </span>                :                  &quot;* sizeof (wchar_t)&quot;);
<span class="lineNum">     469 </span>                : 
<span class="lineNum">     470 </span>                : __extern_always_inline size_t
<span class="lineNum">     471 </span><span class="lineNoCov">              0 : __NTH (mbsrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src,</span>
<span class="lineNum">     472 </span>                :                   size_t __len, mbstate_t *__restrict __ps))
<span class="lineNum">     473 </span>                : {
<span class="lineNum">     474 </span><span class="lineNoCov">              0 :   if (__bos (__dst) != (size_t) -1)</span>
<span class="lineNum">     475 </span>                :     {
<span class="lineNum">     476 </span><span class="lineNoCov">              0 :       if (!__builtin_constant_p (__len))</span>
<span class="lineNum">     477 </span>                :         return __mbsrtowcs_chk (__dst, __src, __len, __ps,
<span class="lineNum">     478 </span><span class="lineNoCov">              0 :                                 __bos (__dst) / sizeof (wchar_t));</span>
<span class="lineNum">     479 </span>                : 
<span class="lineNum">     480 </span><span class="lineNoCov">              0 :       if (__len &gt; __bos (__dst) / sizeof (wchar_t))</span>
<span class="lineNum">     481 </span>                :         return __mbsrtowcs_chk_warn (__dst, __src, __len, __ps,
<span class="lineNum">     482 </span><span class="lineNoCov">              0 :                                      __bos (__dst) / sizeof (wchar_t));</span>
<span class="lineNum">     483 </span>                :     }
<span class="lineNum">     484 </span><span class="lineNoCov">              0 :   return __mbsrtowcs_alias (__dst, __src, __len, __ps);</span>
<span class="lineNum">     485 </span>                : }
<span class="lineNum">     486 </span>                : 
<span class="lineNum">     487 </span>                : 
<span class="lineNum">     488 </span>                : extern size_t __wcsrtombs_chk (char *__restrict __dst,
<span class="lineNum">     489 </span>                :                                __const wchar_t **__restrict __src,
<span class="lineNum">     490 </span>                :                                size_t __len, mbstate_t *__restrict __ps,
<span class="lineNum">     491 </span>                :                                size_t __dstlen) __THROW;
<span class="lineNum">     492 </span>                : extern size_t __REDIRECT_NTH (__wcsrtombs_alias,
<span class="lineNum">     493 </span>                :                               (char *__restrict __dst,
<span class="lineNum">     494 </span>                :                                __const wchar_t **__restrict __src,
<span class="lineNum">     495 </span>                :                                size_t __len, mbstate_t *__restrict __ps),
<span class="lineNum">     496 </span>                :                               wcsrtombs);
<span class="lineNum">     497 </span>                : extern size_t __REDIRECT_NTH (__wcsrtombs_chk_warn,
<span class="lineNum">     498 </span>                :                               (char *__restrict __dst,
<span class="lineNum">     499 </span>                :                                __const wchar_t **__restrict __src,
<span class="lineNum">     500 </span>                :                                size_t __len, mbstate_t *__restrict __ps,
<span class="lineNum">     501 </span>                :                                size_t __dstlen), __wcsrtombs_chk)
<span class="lineNum">     502 </span>                :     __warnattr (&quot;wcsrtombs called with dst buffer smaller than len&quot;);
<span class="lineNum">     503 </span>                : 
<span class="lineNum">     504 </span>                : __extern_always_inline size_t
<span class="lineNum">     505 </span><span class="lineNoCov">              0 : __NTH (wcsrtombs (char *__restrict __dst, __const wchar_t **__restrict __src,</span>
<span class="lineNum">     506 </span>                :                   size_t __len, mbstate_t *__restrict __ps))
<span class="lineNum">     507 </span>                : {
<span class="lineNum">     508 </span><span class="lineNoCov">              0 :   if (__bos (__dst) != (size_t) -1)</span>
<span class="lineNum">     509 </span>                :     {
<span class="lineNum">     510 </span><span class="lineNoCov">              0 :       if (!__builtin_constant_p (__len))</span>
<span class="lineNum">     511 </span><span class="lineNoCov">              0 :         return __wcsrtombs_chk (__dst, __src, __len, __ps, __bos (__dst));</span>
<span class="lineNum">     512 </span>                : 
<span class="lineNum">     513 </span><span class="lineNoCov">              0 :       if (__len &gt; __bos (__dst))</span>
<span class="lineNum">     514 </span><span class="lineNoCov">              0 :         return __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __bos (__dst));</span>
<span class="lineNum">     515 </span>                :     }
<span class="lineNum">     516 </span><span class="lineNoCov">              0 :   return __wcsrtombs_alias (__dst, __src, __len, __ps);</span>
<span class="lineNum">     517 </span>                : }
<span class="lineNum">     518 </span>                : 
<span class="lineNum">     519 </span>                : 
<span class="lineNum">     520 </span>                : #ifdef __USE_GNU
<span class="lineNum">     521 </span>                : extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst,
<span class="lineNum">     522 </span>                :                                 __const char **__restrict __src, size_t __nmc,
<span class="lineNum">     523 </span>                :                                 size_t __len, mbstate_t *__restrict __ps,
<span class="lineNum">     524 </span>                :                                 size_t __dstlen) __THROW;
<span class="lineNum">     525 </span>                : extern size_t __REDIRECT_NTH (__mbsnrtowcs_alias,
<span class="lineNum">     526 </span>                :                               (wchar_t *__restrict __dst,
<span class="lineNum">     527 </span>                :                                __const char **__restrict __src, size_t __nmc,
<span class="lineNum">     528 </span>                :                                size_t __len, mbstate_t *__restrict __ps),
<span class="lineNum">     529 </span>                :                               mbsnrtowcs);
<span class="lineNum">     530 </span>                : extern size_t __REDIRECT_NTH (__mbsnrtowcs_chk_warn,
<span class="lineNum">     531 </span>                :                               (wchar_t *__restrict __dst,
<span class="lineNum">     532 </span>                :                                __const char **__restrict __src, size_t __nmc,
<span class="lineNum">     533 </span>                :                                size_t __len, mbstate_t *__restrict __ps,
<span class="lineNum">     534 </span>                :                                size_t __dstlen), __mbsnrtowcs_chk)
<span class="lineNum">     535 </span>                :      __warnattr (&quot;mbsnrtowcs called with dst buffer smaller than len &quot;
<span class="lineNum">     536 </span>                :                  &quot;* sizeof (wchar_t)&quot;);
<span class="lineNum">     537 </span>                : 
<span class="lineNum">     538 </span>                : __extern_always_inline size_t
<span class="lineNum">     539 </span><span class="lineNoCov">              0 : __NTH (mbsnrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src,</span>
<span class="lineNum">     540 </span>                :                    size_t __nmc, size_t __len, mbstate_t *__restrict __ps))
<span class="lineNum">     541 </span>                : {
<span class="lineNum">     542 </span><span class="lineNoCov">              0 :   if (__bos (__dst) != (size_t) -1)</span>
<span class="lineNum">     543 </span>                :     {
<span class="lineNum">     544 </span><span class="lineNoCov">              0 :       if (!__builtin_constant_p (__len))</span>
<span class="lineNum">     545 </span>                :         return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps,
<span class="lineNum">     546 </span><span class="lineNoCov">              0 :                                  __bos (__dst) / sizeof (wchar_t));</span>
<span class="lineNum">     547 </span>                : 
<span class="lineNum">     548 </span><span class="lineNoCov">              0 :       if (__len &gt; __bos (__dst) / sizeof (wchar_t))</span>
<span class="lineNum">     549 </span>                :         return __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps,
<span class="lineNum">     550 </span><span class="lineNoCov">              0 :                                       __bos (__dst) / sizeof (wchar_t));</span>
<span class="lineNum">     551 </span>                :     }
<span class="lineNum">     552 </span><span class="lineNoCov">              0 :   return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps);</span>
<span class="lineNum">     553 </span>                : }
<span class="lineNum">     554 </span>                : 
<span class="lineNum">     555 </span>                : 
<span class="lineNum">     556 </span>                : extern size_t __wcsnrtombs_chk (char *__restrict __dst,
<span class="lineNum">     557 </span>                :                                 __const wchar_t **__restrict __src,
<span class="lineNum">     558 </span>                :                                 size_t __nwc, size_t __len,
<span class="lineNum">     559 </span>                :                                 mbstate_t *__restrict __ps, size_t __dstlen)
<span class="lineNum">     560 </span>                :      __THROW;
<span class="lineNum">     561 </span>                : extern size_t __REDIRECT_NTH (__wcsnrtombs_alias,
<span class="lineNum">     562 </span>                :                               (char *__restrict __dst,
<span class="lineNum">     563 </span>                :                                __const wchar_t **__restrict __src,
<span class="lineNum">     564 </span>                :                                size_t __nwc, size_t __len,
<span class="lineNum">     565 </span>                :                                mbstate_t *__restrict __ps), wcsnrtombs);
<span class="lineNum">     566 </span>                : extern size_t __REDIRECT_NTH (__wcsnrtombs_chk_warn,
<span class="lineNum">     567 </span>                :                               (char *__restrict __dst,
<span class="lineNum">     568 </span>                :                                __const wchar_t **__restrict __src,
<span class="lineNum">     569 </span>                :                                size_t __nwc, size_t __len,
<span class="lineNum">     570 </span>                :                                mbstate_t *__restrict __ps,
<span class="lineNum">     571 </span>                :                                size_t __dstlen), __wcsnrtombs_chk)
<span class="lineNum">     572 </span>                :      __warnattr (&quot;wcsnrtombs called with dst buffer smaller than len&quot;);
<span class="lineNum">     573 </span>                : 
<span class="lineNum">     574 </span>                : __extern_always_inline size_t
<span class="lineNum">     575 </span><span class="lineNoCov">              0 : __NTH (wcsnrtombs (char *__restrict __dst, __const wchar_t **__restrict __src,</span>
<span class="lineNum">     576 </span>                :                    size_t __nwc, size_t __len, mbstate_t *__restrict __ps))
<span class="lineNum">     577 </span>                : {
<span class="lineNum">     578 </span><span class="lineNoCov">              0 :   if (__bos (__dst) != (size_t) -1)</span>
<span class="lineNum">     579 </span>                :     {
<span class="lineNum">     580 </span><span class="lineNoCov">              0 :       if (!__builtin_constant_p (__len))</span>
<span class="lineNum">     581 </span>                :         return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps,
<span class="lineNum">     582 </span><span class="lineNoCov">              0 :                                  __bos (__dst));</span>
<span class="lineNum">     583 </span>                : 
<span class="lineNum">     584 </span><span class="lineNoCov">              0 :       if (__len &gt; __bos (__dst))</span>
<span class="lineNum">     585 </span>                :         return __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps,
<span class="lineNum">     586 </span><span class="lineNoCov">              0 :                                       __bos (__dst));</span>
<span class="lineNum">     587 </span>                :     }
<span class="lineNum">     588 </span><span class="lineNoCov">              0 :   return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps);</span>
<span class="lineNum">     589 </span>                : }
<span class="lineNum">     590 </span>                : #endif
</pre>
      </td>
    </tr>
  </table>
  <br>

  <table width="100%" border=0 cellspacing=0 cellpadding=0>
  <tr><td class="ruler"><img src="../../../glass.png" width=3 height=3 alt=""></td></tr>
  <tr><td class="versionInfo">Generated by: <a href="http://ltp.sourceforge.net/coverage/lcov.php" target="_parent">LTP GCOV extension version 1.6</a></td></tr>
  </table>
  <br>

</body>
</html>
